package co.edu.usbcali.sgi.presentation.businessDelegate;

import co.edu.usbcali.sgi.modelo.Administrador;
import co.edu.usbcali.sgi.modelo.Autorizacion;
import co.edu.usbcali.sgi.modelo.Ciudad;
import co.edu.usbcali.sgi.modelo.Concepto;
import co.edu.usbcali.sgi.modelo.Correspondencia;
import co.edu.usbcali.sgi.modelo.CuentaBancaria;
import co.edu.usbcali.sgi.modelo.DetalleCorrespondencia;
import co.edu.usbcali.sgi.modelo.DetalleFactura;
import co.edu.usbcali.sgi.modelo.Division;
import co.edu.usbcali.sgi.modelo.Estado;
import co.edu.usbcali.sgi.modelo.Factura;
import co.edu.usbcali.sgi.modelo.GrupoFamiliar;
import co.edu.usbcali.sgi.modelo.Inmueble;
import co.edu.usbcali.sgi.modelo.Marca;
import co.edu.usbcali.sgi.modelo.MovMesInmueble;
import co.edu.usbcali.sgi.modelo.Multa;
import co.edu.usbcali.sgi.modelo.Pais;
import co.edu.usbcali.sgi.modelo.Parametros;
import co.edu.usbcali.sgi.modelo.Persona;
import co.edu.usbcali.sgi.modelo.Presupuesto;
import co.edu.usbcali.sgi.modelo.PropietarioInmueble;
import co.edu.usbcali.sgi.modelo.Recepcion;
import co.edu.usbcali.sgi.modelo.Reserva;
import co.edu.usbcali.sgi.modelo.Rubro;
import co.edu.usbcali.sgi.modelo.TipoCategoria;
import co.edu.usbcali.sgi.modelo.TipoConcepto;
import co.edu.usbcali.sgi.modelo.TipoCorrespondencia;
import co.edu.usbcali.sgi.modelo.TipoCuentaBancaria;
import co.edu.usbcali.sgi.modelo.TipoDocumento;
import co.edu.usbcali.sgi.modelo.TipoUsuario;
import co.edu.usbcali.sgi.modelo.TipoVehiculo;
import co.edu.usbcali.sgi.modelo.TipoZonaComun;
import co.edu.usbcali.sgi.modelo.TipoZonaExtra;
import co.edu.usbcali.sgi.modelo.UnidadResidencial;
import co.edu.usbcali.sgi.modelo.Usuario;
import co.edu.usbcali.sgi.modelo.Vehiculo;
import co.edu.usbcali.sgi.modelo.ZonaComun;
import co.edu.usbcali.sgi.modelo.ZonaExtra;
import co.edu.usbcali.sgi.modelo.control.AdministradorLogic;
import co.edu.usbcali.sgi.modelo.control.AutorizacionLogic;
import co.edu.usbcali.sgi.modelo.control.CiudadLogic;
import co.edu.usbcali.sgi.modelo.control.ConceptoLogic;
import co.edu.usbcali.sgi.modelo.control.CorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.CuentaBancariaLogic;
import co.edu.usbcali.sgi.modelo.control.DetalleCorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.DetalleFacturaLogic;
import co.edu.usbcali.sgi.modelo.control.DivisionLogic;
import co.edu.usbcali.sgi.modelo.control.EstadoLogic;
import co.edu.usbcali.sgi.modelo.control.FacturaLogic;
import co.edu.usbcali.sgi.modelo.control.GrupoFamiliarLogic;
import co.edu.usbcali.sgi.modelo.control.IAdministradorLogic;
import co.edu.usbcali.sgi.modelo.control.IAutorizacionLogic;
import co.edu.usbcali.sgi.modelo.control.ICiudadLogic;
import co.edu.usbcali.sgi.modelo.control.IConceptoLogic;
import co.edu.usbcali.sgi.modelo.control.ICorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.ICuentaBancariaLogic;
import co.edu.usbcali.sgi.modelo.control.IDetalleCorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.IDetalleFacturaLogic;
import co.edu.usbcali.sgi.modelo.control.IDivisionLogic;
import co.edu.usbcali.sgi.modelo.control.IEstadoLogic;
import co.edu.usbcali.sgi.modelo.control.IFacturaLogic;
import co.edu.usbcali.sgi.modelo.control.IGrupoFamiliarLogic;
import co.edu.usbcali.sgi.modelo.control.IInmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.ILoginLogic;
import co.edu.usbcali.sgi.modelo.control.IMarcaLogic;
import co.edu.usbcali.sgi.modelo.control.IMovMesInmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.IMultaLogic;
import co.edu.usbcali.sgi.modelo.control.IPaisLogic;
import co.edu.usbcali.sgi.modelo.control.IParametrosLogic;
import co.edu.usbcali.sgi.modelo.control.IPersonaLogic;
import co.edu.usbcali.sgi.modelo.control.IPresupuestoLogic;
import co.edu.usbcali.sgi.modelo.control.IPropietarioInmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.IRecepcionLogic;
import co.edu.usbcali.sgi.modelo.control.IReservaLogic;
import co.edu.usbcali.sgi.modelo.control.IRubroLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoCategoriaLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoConceptoLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoCorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoCuentaBancariaLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoDocumentoLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoUsuarioLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoVehiculoLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoZonaComunLogic;
import co.edu.usbcali.sgi.modelo.control.ITipoZonaExtraLogic;
import co.edu.usbcali.sgi.modelo.control.IUnidadResidencialLogic;
import co.edu.usbcali.sgi.modelo.control.IUsuarioLogic;
import co.edu.usbcali.sgi.modelo.control.IVehiculoLogic;
import co.edu.usbcali.sgi.modelo.control.IZonaComunLogic;
import co.edu.usbcali.sgi.modelo.control.IZonaExtraLogic;
import co.edu.usbcali.sgi.modelo.control.InmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.LoginLogic;
import co.edu.usbcali.sgi.modelo.control.MarcaLogic;
import co.edu.usbcali.sgi.modelo.control.MovMesInmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.MultaLogic;
import co.edu.usbcali.sgi.modelo.control.PaisLogic;
import co.edu.usbcali.sgi.modelo.control.ParametrosLogic;
import co.edu.usbcali.sgi.modelo.control.PersonaLogic;
import co.edu.usbcali.sgi.modelo.control.PresupuestoLogic;
import co.edu.usbcali.sgi.modelo.control.PropietarioInmuebleLogic;
import co.edu.usbcali.sgi.modelo.control.RecepcionLogic;
import co.edu.usbcali.sgi.modelo.control.ReservaLogic;
import co.edu.usbcali.sgi.modelo.control.RubroLogic;
import co.edu.usbcali.sgi.modelo.control.TipoCategoriaLogic;
import co.edu.usbcali.sgi.modelo.control.TipoConceptoLogic;
import co.edu.usbcali.sgi.modelo.control.TipoCorrespondenciaLogic;
import co.edu.usbcali.sgi.modelo.control.TipoCuentaBancariaLogic;
import co.edu.usbcali.sgi.modelo.control.TipoDocumentoLogic;
import co.edu.usbcali.sgi.modelo.control.TipoUsuarioLogic;
import co.edu.usbcali.sgi.modelo.control.TipoVehiculoLogic;
import co.edu.usbcali.sgi.modelo.control.TipoZonaComunLogic;
import co.edu.usbcali.sgi.modelo.control.TipoZonaExtraLogic;
import co.edu.usbcali.sgi.modelo.control.UnidadResidencialLogic;
import co.edu.usbcali.sgi.modelo.control.UsuarioLogic;
import co.edu.usbcali.sgi.modelo.control.VehiculoLogic;
import co.edu.usbcali.sgi.modelo.control.ZonaComunLogic;
import co.edu.usbcali.sgi.modelo.control.ZonaExtraLogic;

import java.math.BigDecimal;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;


/**
* Use a Business Delegate to reduce coupling between presentation-tier clients and business services.
* The Business Delegate hides the underlying implementation details of the business service, such as lookup and access details of the EJB architecture.
*
* The Business Delegate acts as a client-side business abstraction; it provides an abstraction for, and thus hides,
* the implementation of the business services. Using a Business Delegate reduces the coupling between presentation-tier clients and
* the system's business services. Depending on the implementation strategy, the Business Delegate may shield clients from possible
* volatility in the implementation of the business service API. Potentially, this reduces the number of changes that must be made to the
* presentation-tier client code when the business service API or its underlying implementation changes.
*
* However, interface methods in the Business Delegate may still require modification if the underlying business service API changes.
* Admittedly, though, it is more likely that changes will be made to the business service rather than to the Business Delegate.
*
* Often, developers are skeptical when a design goal such as abstracting the business layer causes additional upfront work in return
* for future gains. However, using this pattern or its strategies results in only a small amount of additional upfront work and provides
* considerable benefits. The main benefit is hiding the details of the underlying service. For example, the client can become transparent
* to naming and lookup services. The Business Delegate also handles the exceptions from the business services, such as java.rmi.Remote
* exceptions, Java Messages Service (JMS) exceptions and so on. The Business Delegate may intercept such service level exceptions and
* generate application level exceptions instead. Application level exceptions are easier to handle by the clients, and may be user friendly.
* The Business Delegate may also transparently perform any retry or recovery operations necessary in the event of a service failure without
* exposing the client to the problem until it is determined that the problem is not resolvable. These gains present a compelling reason to
* use the pattern.
*
* Another benefit is that the delegate may cache results and references to remote business services. Caching can significantly improve performance,
* because it limits unnecessary and potentially costly round trips over the network.
*
* A Business Delegate uses a component called the Lookup Service. The Lookup Service is responsible for hiding the underlying implementation
* details of the business service lookup code. The Lookup Service may be written as part of the Delegate, but we recommend that it be
* implemented as a separate component, as outlined in the Service Locator pattern (See "Service Locator" on page 368.)
*
* When the Business Delegate is used with a Session Facade, typically there is a one-to-one relationship between the two.
* This one-to-one relationship exists because logic that might have been encapsulated in a Business Delegate relating to its interaction
* with multiple business services (creating a one-to-many relationship) will often be factored back into a Session Facade.
*
* Finally, it should be noted that this pattern could be used to reduce coupling between other tiers, not simply the presentation and the
* business tiers.
*
* @author Zathura Code Generator http://code.google.com/p/zathura
*
*/
public class BusinessDelegatorView {
    private BusinessDelegatorView() {
    }

    public static List<Administrador> getAdministrador()
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.getAdministrador();
    }

    public static void saveAdministrador( String estCod_Estado,
        String perCedula_Persona) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.saveAdministrador( estCod_Estado,
            perCedula_Persona);
    }

    public static void deleteAdministrador(String admCod)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.deleteAdministrador(admCod);
    }

    public static void updateAdministrador( String estCod_Estado,
        String perCedula_Persona) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.updateAdministrador( estCod_Estado,
            perCedula_Persona);
    }

    public static Administrador getAdministrador(String admCod)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        Administrador administrador = null;

        try {
            administrador = administradorLogic.getAdministrador(admCod);
        } catch (Exception e) {
            throw e;
        }

        return administrador;
    }

    public static List<Administrador> findByCriteriaInAdministrador(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Administrador> findPageAdministrador(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findPageAdministrador(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAdministrador() throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findTotalNumberAdministrador();
    }

    public static List<Autorizacion> getAutorizacion()
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.getAutorizacion();
    }

    public static void saveAutorizacion(String autCedVisitante, String autCod,
        String autDescripcion, String autEmpresa, Date autFecha,
        String autNombreVisitante, String estCod_Estado,
        String proInmCod_PropietarioInmueble) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.saveAutorizacion(autCedVisitante, autCod,
            autDescripcion, autEmpresa, autFecha, autNombreVisitante,
            estCod_Estado, proInmCod_PropietarioInmueble);
    }

    public static void deleteAutorizacion(String autCod)
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.deleteAutorizacion(autCod);
    }

    public static void updateAutorizacion(String autCedVisitante,
        String autCod, String autDescripcion, String autEmpresa, Date autFecha,
        String autNombreVisitante, String estCod_Estado,
        String proInmCod_PropietarioInmueble) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.updateAutorizacion(autCedVisitante, autCod,
            autDescripcion, autEmpresa, autFecha, autNombreVisitante,
            estCod_Estado, proInmCod_PropietarioInmueble);
    }

    public static Autorizacion getAutorizacion(String autCod)
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        Autorizacion autorizacion = null;

        try {
            autorizacion = autorizacionLogic.getAutorizacion(autCod);
        } catch (Exception e) {
            throw e;
        }

        return autorizacion;
    }

    public static List<Autorizacion> findByCriteriaInAutorizacion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Autorizacion> findPageAutorizacion(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findPageAutorizacion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAutorizacion() throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findTotalNumberAutorizacion();
    }

    public static List<Ciudad> getCiudad() throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.getCiudad();
    }

    public static void saveCiudad( String ciuNombre,
        String estCod_Estado, String paiCod_Pais) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.saveCiudad( ciuNombre, estCod_Estado, paiCod_Pais);
    }

    public static void deleteCiudad(String ciuCod) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.deleteCiudad(ciuCod);
    }

    public static void updateCiudad( String ciuNombre,
        String estCod_Estado, String paiCod_Pais) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.updateCiudad (ciuNombre, estCod_Estado, paiCod_Pais);
    }

    public static Ciudad getCiudad(String ciuCod) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        Ciudad ciudad = null;

        try {
            ciudad = ciudadLogic.getCiudad(ciuCod);
        } catch (Exception e) {
            throw e;
        }

        return ciudad;
    }

    public static List<Ciudad> findByCriteriaInCiudad(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Ciudad> findPageCiudad(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findPageCiudad(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCiudad() throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findTotalNumberCiudad();
    }

    public static List<Concepto> getConcepto() throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.getConcepto();
    }

    public static void saveConcepto(String conCod, String conPorcentajeImpre,
        String conValor, String preCod_Presupuesto,
        String tcaCod_TipoCategoria, String tcoCod_TipoConcepto)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.saveConcepto(conCod, conPorcentajeImpre, conValor,
            preCod_Presupuesto, tcaCod_TipoCategoria, tcoCod_TipoConcepto);
    }

    public static void deleteConcepto(String conCod) throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.deleteConcepto(conCod);
    }

    public static void updateConcepto(String conCod, String conPorcentajeImpre,
        String conValor, String preCod_Presupuesto,
        String tcaCod_TipoCategoria, String tcoCod_TipoConcepto)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.updateConcepto(conCod, conPorcentajeImpre, conValor,
            preCod_Presupuesto, tcaCod_TipoCategoria, tcoCod_TipoConcepto);
    }

    public static Concepto getConcepto(String conCod) throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        Concepto concepto = null;

        try {
            concepto = conceptoLogic.getConcepto(conCod);
        } catch (Exception e) {
            throw e;
        }

        return concepto;
    }

    public static List<Concepto> findByCriteriaInConcepto(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Concepto> findPageConcepto(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findPageConcepto(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberConcepto() throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findTotalNumberConcepto();
    }

    public static List<Correspondencia> getCorrespondencia()
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.getCorrespondencia();
    }

    public static void saveCorrespondencia(String corAsunto, String corCod,
        String tpcCod_TipoCorrespondencia) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.saveCorrespondencia(corAsunto, corCod,
            tpcCod_TipoCorrespondencia);
    }

    public static void deleteCorrespondencia(String corCod)
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.deleteCorrespondencia(corCod);
    }

    public static void updateCorrespondencia(String corAsunto, String corCod,
        String tpcCod_TipoCorrespondencia) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.updateCorrespondencia(corAsunto, corCod,
            tpcCod_TipoCorrespondencia);
    }

    public static Correspondencia getCorrespondencia(String corCod)
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        Correspondencia correspondencia = null;

        try {
            correspondencia = correspondenciaLogic.getCorrespondencia(corCod);
        } catch (Exception e) {
            throw e;
        }

        return correspondencia;
    }

    public static List<Correspondencia> findByCriteriaInCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Correspondencia> findPageCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findPageCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCorrespondencia()
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findTotalNumberCorrespondencia();
    }

    public static List<CuentaBancaria> getCuentaBancaria()
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();

        return cuentaBancariaLogic.getCuentaBancaria();
    }

    public static void saveCuentaBancaria(Long ctaClave, 
        String ctaNumero, Long ctaSaldo, String estCod_Estado,
        String perCedula_Persona, String tctaCod_TipoCuentaBancaria)
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();
        cuentaBancariaLogic.saveCuentaBancaria(ctaClave,  ctaNumero,
            ctaSaldo, estCod_Estado, perCedula_Persona,
            tctaCod_TipoCuentaBancaria);
    }

    public static void deleteCuentaBancaria(String ctaCod)
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();
        cuentaBancariaLogic.deleteCuentaBancaria(ctaCod);
    }

    public static void updateCuentaBancaria(Long ctaClave,
        String ctaNumero, String perCedula_Persona, String estCod_Estado,
        Long ctaSaldo, String tctaCod_TipoCuentaBancaria)
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();
        cuentaBancariaLogic.updateCuentaBancaria(ctaClave,  ctaNumero,
            ctaSaldo, estCod_Estado, perCedula_Persona,
            tctaCod_TipoCuentaBancaria);
    }

    public static CuentaBancaria getCuentaBancaria(String ctaCod)
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();
        CuentaBancaria cuentaBancaria = null;

        try {
            cuentaBancaria = cuentaBancariaLogic.getCuentaBancaria(ctaCod);
        } catch (Exception e) {
            throw e;
        }

        return cuentaBancaria;
    }

    public static List<CuentaBancaria> findByCriteriaInCuentaBancaria(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();

        return cuentaBancariaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<CuentaBancaria> findPageCuentaBancaria(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();

        return cuentaBancariaLogic.findPageCuentaBancaria(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCuentaBancaria()
        throws Exception {
        ICuentaBancariaLogic cuentaBancariaLogic = new CuentaBancariaLogic();

        return cuentaBancariaLogic.findTotalNumberCuentaBancaria();
    }

    public static List<DetalleCorrespondencia> getDetalleCorrespondencia()
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.getDetalleCorrespondencia();
    }

    public static void saveDetalleCorrespondencia(String dtcCod,
        Date dtcFechaEnvio, String corCod_Correspondencia,
        String estCod_Estado, String perCedula_Persona)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.saveDetalleCorrespondencia(dtcCod,
            dtcFechaEnvio, corCod_Correspondencia, estCod_Estado,
            perCedula_Persona);
    }

    public static void deleteDetalleCorrespondencia(String dtcCod)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.deleteDetalleCorrespondencia(dtcCod);
    }

    public static void updateDetalleCorrespondencia(String dtcCod,
        Date dtcFechaEnvio, String corCod_Correspondencia,
        String estCod_Estado, String perCedula_Persona)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.updateDetalleCorrespondencia(dtcCod,
            dtcFechaEnvio, corCod_Correspondencia, estCod_Estado,
            perCedula_Persona);
    }

    public static DetalleCorrespondencia getDetalleCorrespondencia(
        String dtcCod) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        DetalleCorrespondencia detalleCorrespondencia = null;

        try {
            detalleCorrespondencia = detalleCorrespondenciaLogic.getDetalleCorrespondencia(dtcCod);
        } catch (Exception e) {
            throw e;
        }

        return detalleCorrespondencia;
    }

    public static List<DetalleCorrespondencia> findByCriteriaInDetalleCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<DetalleCorrespondencia> findPageDetalleCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findPageDetalleCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDetalleCorrespondencia()
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findTotalNumberDetalleCorrespondencia();
    }

    public static List<DetalleFactura> getDetalleFactura()
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.getDetalleFactura();
    }

    public static void saveDetalleFactura(String dtfCod, String dtfValor,
        String facCod_Factura, String mviCod_MovMesInmueble, String rubCod_Rubro)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.saveDetalleFactura(dtfCod, dtfValor,
            facCod_Factura, mviCod_MovMesInmueble, rubCod_Rubro);
    }

    public static void deleteDetalleFactura(String dtfCod)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.deleteDetalleFactura(dtfCod);
    }

    public static void updateDetalleFactura(String dtfCod, String dtfValor,
        String facCod_Factura, String mviCod_MovMesInmueble, String rubCod_Rubro)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.updateDetalleFactura(dtfCod, dtfValor,
            facCod_Factura, mviCod_MovMesInmueble, rubCod_Rubro);
    }

    public static DetalleFactura getDetalleFactura(String dtfCod)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        DetalleFactura detalleFactura = null;

        try {
            detalleFactura = detalleFacturaLogic.getDetalleFactura(dtfCod);
        } catch (Exception e) {
            throw e;
        }

        return detalleFactura;
    }

    public static List<DetalleFactura> findByCriteriaInDetalleFactura(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<DetalleFactura> findPageDetalleFactura(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findPageDetalleFactura(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDetalleFactura()
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findTotalNumberDetalleFactura();
    }

    public static List<Division> getDivision() throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.getDivision();
    }

    public static void saveDivision(String divCod, String divNombre,
        String estCod_Estado, String unrNit_UnidadResidencial)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.saveDivision(divCod, divNombre, estCod_Estado,
            unrNit_UnidadResidencial);
    }

    public static void deleteDivision(String divCod) throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.deleteDivision(divCod);
    }

    public static void updateDivision(String divCod, String divNombre,
        String estCod_Estado, String unrNit_UnidadResidencial)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.updateDivision(divCod, divNombre, estCod_Estado,
            unrNit_UnidadResidencial);
    }

    public static Division getDivision(String divCod) throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        Division division = null;

        try {
            division = divisionLogic.getDivision(divCod);
        } catch (Exception e) {
            throw e;
        }

        return division;
    }

    public static List<Division> findByCriteriaInDivision(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Division> findPageDivision(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findPageDivision(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberDivision() throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findTotalNumberDivision();
    }

    public static List<Estado> getEstado() throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.getEstado();
    }

    public static void saveEstado(String estCod, String estNombre)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.saveEstado(estCod, estNombre);
    }

    public static void deleteEstado(String estCod) throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.deleteEstado(estCod);
    }

    public static void updateEstado(String estCod, String estNombre)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.updateEstado(estCod, estNombre);
    }

    public static Estado getEstado(String estCod) throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        Estado estado = null;

        try {
            estado = estadoLogic.getEstado(estCod);
        } catch (Exception e) {
            throw e;
        }

        return estado;
    }

    public static List<Estado> findByCriteriaInEstado(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Estado> findPageEstado(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findPageEstado(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberEstado() throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findTotalNumberEstado();
    }

    public static List<Factura> getFactura() throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.getFactura();
    }

    public static void saveFactura(String facCod, Date facFecha,
        String estCod_Estado, String proInmCod_PropietarioInmueble)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.saveFactura(facCod, facFecha, estCod_Estado,
            proInmCod_PropietarioInmueble);
    }

    public static void deleteFactura(String facCod) throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.deleteFactura(facCod);
    }

    public static void updateFactura(String facCod, Date facFecha,
        String estCod_Estado, String proInmCod_PropietarioInmueble)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.updateFactura(facCod, facFecha, estCod_Estado,
            proInmCod_PropietarioInmueble);
    }

    public static Factura getFactura(String facCod) throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        Factura factura = null;

        try {
            factura = facturaLogic.getFactura(facCod);
        } catch (Exception e) {
            throw e;
        }

        return factura;
    }

    public static List<Factura> findByCriteriaInFactura(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Factura> findPageFactura(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findPageFactura(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberFactura() throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findTotalNumberFactura();
    }

    public static List<GrupoFamiliar> getGrupoFamiliar()
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.getGrupoFamiliar();
    }

    public static void saveGrupoFamiliar(String grfCod, String estCod_Estado,
        String perCedula_Persona, String proInmCod_PropietarioInmueble)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.saveGrupoFamiliar(grfCod, estCod_Estado,
            perCedula_Persona, proInmCod_PropietarioInmueble);
    }

    public static void deleteGrupoFamiliar(String grfCod)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.deleteGrupoFamiliar(grfCod);
    }

    public static void updateGrupoFamiliar(String grfCod, String estCod_Estado,
        String perCedula_Persona, String proInmCod_PropietarioInmueble)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.updateGrupoFamiliar(grfCod, estCod_Estado,
            perCedula_Persona, proInmCod_PropietarioInmueble);
    }

    public static GrupoFamiliar getGrupoFamiliar(String grfCod)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        GrupoFamiliar grupoFamiliar = null;

        try {
            grupoFamiliar = grupoFamiliarLogic.getGrupoFamiliar(grfCod);
        } catch (Exception e) {
            throw e;
        }

        return grupoFamiliar;
    }

    public static List<GrupoFamiliar> findByCriteriaInGrupoFamiliar(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<GrupoFamiliar> findPageGrupoFamiliar(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findPageGrupoFamiliar(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberGrupoFamiliar() throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findTotalNumberGrupoFamiliar();
    }

    public static List<Inmueble> getInmueble() throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.getInmueble();
    }

    public static void saveInmueble(String inmDimension, String inmId,
        String divCod_Division, String estCod_Estado) throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.saveInmueble(inmDimension, inmId, divCod_Division,
            estCod_Estado);
    }

    public static void deleteInmueble(String inmId) throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.deleteInmueble(inmId);
    }

    public static void updateInmueble(String inmDimension, String inmId,
        String divCod_Division, String estCod_Estado) throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.updateInmueble(inmDimension, inmId, divCod_Division,
            estCod_Estado);
    }

    public static Inmueble getInmueble(String inmId) throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        Inmueble inmueble = null;

        try {
            inmueble = inmuebleLogic.getInmueble(inmId);
        } catch (Exception e) {
            throw e;
        }

        return inmueble;
    }

    public static List<Inmueble> findByCriteriaInInmueble(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Inmueble> findPageInmueble(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findPageInmueble(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberInmueble() throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findTotalNumberInmueble();
    }

    public static List<Marca> getMarca() throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();

        return marcaLogic.getMarca();
    }

    public static void saveMarca(String marCod, String marNombre,
        String tpvCod_TipoVehiculo) throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();
        marcaLogic.saveMarca(marCod, marNombre, tpvCod_TipoVehiculo);
    }

    public static void deleteMarca(String marCod) throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();
        marcaLogic.deleteMarca(marCod);
    }

    public static void updateMarca(String marCod, String marNombre,
        String tpvCod_TipoVehiculo) throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();
        marcaLogic.updateMarca(marCod, marNombre, tpvCod_TipoVehiculo);
    }

    public static Marca getMarca(String marCod) throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();
        Marca marca = null;

        try {
            marca = marcaLogic.getMarca(marCod);
        } catch (Exception e) {
            throw e;
        }

        return marca;
    }

    public static List<Marca> findByCriteriaInMarca(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();

        return marcaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Marca> findPageMarca(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();

        return marcaLogic.findPageMarca(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberMarca() throws Exception {
        IMarcaLogic marcaLogic = new MarcaLogic();

        return marcaLogic.findTotalNumberMarca();
    }

    public static List<MovMesInmueble> getMovMesInmueble()
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.getMovMesInmueble();
    }

    public static void saveMovMesInmueble(String mviCod, String mviFecha,
        String inmId_Inmueble, String mulCod_Multa) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.saveMovMesInmueble(mviCod, mviFecha,
            inmId_Inmueble, mulCod_Multa);
    }

    public static void deleteMovMesInmueble(String mviCod)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.deleteMovMesInmueble(mviCod);
    }

    public static void updateMovMesInmueble(String mviCod, String mviFecha,
        String inmId_Inmueble, String mulCod_Multa) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.updateMovMesInmueble(mviCod, mviFecha,
            inmId_Inmueble, mulCod_Multa);
    }

    public static MovMesInmueble getMovMesInmueble(String mviCod)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        MovMesInmueble movMesInmueble = null;

        try {
            movMesInmueble = movMesInmuebleLogic.getMovMesInmueble(mviCod);
        } catch (Exception e) {
            throw e;
        }

        return movMesInmueble;
    }

    public static List<MovMesInmueble> findByCriteriaInMovMesInmueble(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<MovMesInmueble> findPageMovMesInmueble(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findPageMovMesInmueble(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberMovMesInmueble()
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findTotalNumberMovMesInmueble();
    }

    public static List<Multa> getMulta() throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.getMulta();
    }

    public static void saveMulta(String mulCod, String mulNombre,
        String mulValor) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.saveMulta(mulCod, mulNombre, mulValor);
    }

    public static void deleteMulta(String mulCod) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.deleteMulta(mulCod);
    }

    public static void updateMulta(String mulCod, String mulNombre,
        String mulValor) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.updateMulta(mulCod, mulNombre, mulValor);
    }

    public static Multa getMulta(String mulCod) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        Multa multa = null;

        try {
            multa = multaLogic.getMulta(mulCod);
        } catch (Exception e) {
            throw e;
        }

        return multa;
    }

    public static List<Multa> findByCriteriaInMulta(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Multa> findPageMulta(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findPageMulta(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberMulta() throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findTotalNumberMulta();
    }

    public static List<Pais> getPais() throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.getPais();
    }

    public static void savePais( String paiNombre,
        String estCod_Estado) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.savePais( paiNombre, estCod_Estado);
    }

    public static void deletePais(String paiCod) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.deletePais(paiCod);
    }

    public static void updatePais( String paiNombre,
        String estCod_Estado) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.updatePais( paiNombre, estCod_Estado);
    }

    public static Pais getPais(String paiNombre) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        Pais pais = null;

        try {
            pais = paisLogic.getPais(paiNombre);
        } catch (Exception e) {
            throw e;
        }

        return pais;
    }

    public static List<Pais> findByCriteriaInPais(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates );
    }

    public static List<Pais> findPagePais(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findPagePais(sortColumnName, sortAscending, startRow,
            maxResults);
    }

    public static Long findTotalNumberPais() throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findTotalNumberPais();
    }

    public static List<Parametros> getParametros() throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();

        return parametrosLogic.getParametros();
    }

    public static void saveParametros(String parCod, String parValor1,
        String parValor2) throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();
        parametrosLogic.saveParametros(parCod, parValor1, parValor2);
    }

    public static void deleteParametros(String parCod)
        throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();
        parametrosLogic.deleteParametros(parCod);
    }

    public static void updateParametros(String parCod, String parValor1,
        String parValor2) throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();
        parametrosLogic.updateParametros(parCod, parValor1, parValor2);
    }

    public static Parametros getParametros(String parCod)
        throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();
        Parametros parametros = null;

        try {
            parametros = parametrosLogic.getParametros(parCod);
        } catch (Exception e) {
            throw e;
        }

        return parametros;
    }

    public static List<Parametros> findByCriteriaInParametros(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();

        return parametrosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Parametros> findPageParametros(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();

        return parametrosLogic.findPageParametros(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberParametros() throws Exception {
        IParametrosLogic parametrosLogic = new ParametrosLogic();

        return parametrosLogic.findTotalNumberParametros();
    }

    public static List<Persona> getPersona() throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.getPersona();
    }

    public static void savePersona(String perCedula, String perCelular,
        String perCorreo, String perPrimerApellido, String perPrimerNombre,
        String perSegundoApellido, String perSegundoNombre, String perTelefono,
        String estCod_Estado, String tdocCod_TipoDocumento)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.savePersona(perCedula, perCelular, perCorreo,
            perPrimerApellido, perPrimerNombre, perSegundoApellido,
            perSegundoNombre, perTelefono, estCod_Estado, tdocCod_TipoDocumento);
    }

    public static void deletePersona(String perCedula)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.deletePersona(perCedula);
    }

    public static void updatePersona(String perCedula, String perCelular,
        String perCorreo, String perPrimerApellido, String perPrimerNombre,
        String perSegundoApellido, String perSegundoNombre, String perTelefono,
        String estCod_Estado, String tdocCod_TipoDocumento)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.updatePersona(perCedula, perCelular, perCorreo,
            perPrimerApellido, perPrimerNombre, perSegundoApellido,
            perSegundoNombre, perTelefono, estCod_Estado, tdocCod_TipoDocumento);
    }

    public static Persona getPersona(String perCedula)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        Persona persona = null;

        try {
            persona = personaLogic.getPersona(perCedula);
        } catch (Exception e) {
            throw e;
        }

        return persona;
    }

    public static List<Persona> findByCriteriaInPersona(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Persona> findPagePersona(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findPagePersona(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberPersona() throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findTotalNumberPersona();
    }

    public static List<Presupuesto> getPresupuesto() throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.getPresupuesto();
    }

    public static void savePresupuesto(String preCod, String preFecha,
        String preValorTotal, String estCod_Estado,
        String unrNit_UnidadResidencial) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.savePresupuesto(preCod, preFecha, preValorTotal,
            estCod_Estado, unrNit_UnidadResidencial);
    }

    public static void deletePresupuesto(String preCod)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.deletePresupuesto(preCod);
    }

    public static void updatePresupuesto(String preCod, String preFecha,
        String preValorTotal, String estCod_Estado,
        String unrNit_UnidadResidencial) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.updatePresupuesto(preCod, preFecha, preValorTotal,
            estCod_Estado, unrNit_UnidadResidencial);
    }

    public static Presupuesto getPresupuesto(String preCod)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        Presupuesto presupuesto = null;

        try {
            presupuesto = presupuestoLogic.getPresupuesto(preCod);
        } catch (Exception e) {
            throw e;
        }

        return presupuesto;
    }

    public static List<Presupuesto> findByCriteriaInPresupuesto(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Presupuesto> findPagePresupuesto(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findPagePresupuesto(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPresupuesto() throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findTotalNumberPresupuesto();
    }

    public static List<PropietarioInmueble> getPropietarioInmueble()
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.getPropietarioInmueble();
    }

    public static void savePropietarioInmueble(
        String inmId_Inmueble, String perCedula_Persona)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.savePropietarioInmueble(
            inmId_Inmueble, perCedula_Persona);
    }

    public static void deletePropietarioInmueble(String proInmCod)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.deletePropietarioInmueble(proInmCod);
    }

    public static void updatePropietarioInmueble(
        String inmId_Inmueble, String perCedula_Persona)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.updatePropietarioInmueble(
            inmId_Inmueble, perCedula_Persona);
    }

    public static PropietarioInmueble getPropietarioInmueble(String proInmCod)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        PropietarioInmueble propietarioInmueble = null;

        try {
            propietarioInmueble = propietarioInmuebleLogic.getPropietarioInmueble(proInmCod);
        } catch (Exception e) {
            throw e;
        }

        return propietarioInmueble;
    }

    public static List<PropietarioInmueble> findByCriteriaInPropietarioInmueble(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<PropietarioInmueble> findPagePropietarioInmueble(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findPagePropietarioInmueble(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPropietarioInmueble()
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findTotalNumberPropietarioInmueble();
    }

    public static List<Recepcion> getRecepcion() throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.getRecepcion();
    }

    public static void saveRecepcion(String recCodRecepcion,
        Date recFechaRecepcion, String recObservacion,
        String corCod_Correspondencia, String usuCod_Usuario)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.saveRecepcion(recCodRecepcion, recFechaRecepcion,
            recObservacion, corCod_Correspondencia, usuCod_Usuario);
    }

    public static void deleteRecepcion(String recCodRecepcion)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.deleteRecepcion(recCodRecepcion);
    }

    public static void updateRecepcion(String recCodRecepcion,
        Date recFechaRecepcion, String recObservacion,
        String corCod_Correspondencia, String usuCod_Usuario)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.updateRecepcion(recCodRecepcion, recFechaRecepcion,
            recObservacion, corCod_Correspondencia, usuCod_Usuario);
    }

    public static Recepcion getRecepcion(String recCodRecepcion)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        Recepcion recepcion = null;

        try {
            recepcion = recepcionLogic.getRecepcion(recCodRecepcion);
        } catch (Exception e) {
            throw e;
        }

        return recepcion;
    }

    public static List<Recepcion> findByCriteriaInRecepcion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Recepcion> findPageRecepcion(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findPageRecepcion(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberRecepcion() throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findTotalNumberRecepcion();
    }

    public static List<Reserva> getReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.getReserva();
    }

    public static void saveReserva(String resCod, Date resFecha,
        Date resHoraFinal, Date resHoraInicio, String estCod_Estado,
        String proInmCod_PropietarioInmueble, String zcCod_ZonaComun)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.saveReserva(resCod, resFecha, resHoraFinal, resHoraInicio,
            estCod_Estado, proInmCod_PropietarioInmueble, zcCod_ZonaComun);
    }

    public static void deleteReserva(String resCod) throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.deleteReserva(resCod);
    }

    public static void updateReserva(String resCod, Date resFecha,
        Date resHoraFinal, Date resHoraInicio, String estCod_Estado,
        String proInmCod_PropietarioInmueble, String zcCod_ZonaComun)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.updateReserva(resCod, resFecha, resHoraFinal,
            resHoraInicio, estCod_Estado, proInmCod_PropietarioInmueble,
            zcCod_ZonaComun);
    }

    public static Reserva getReserva(String resCod) throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        Reserva reserva = null;

        try {
            reserva = reservaLogic.getReserva(resCod);
        } catch (Exception e) {
            throw e;
        }

        return reserva;
    }

    public static List<Reserva> findByCriteriaInReserva(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Reserva> findPageReserva(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findPageReserva(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findTotalNumberReserva();
    }

    public static List<Rubro> getRubro() throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.getRubro();
    }

    public static void saveRubro(String rubCod, String rubNombre)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.saveRubro(rubCod, rubNombre);
    }

    public static void deleteRubro(String rubCod) throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.deleteRubro(rubCod);
    }

    public static void updateRubro(String rubCod, String rubNombre)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.updateRubro(rubCod, rubNombre);
    }

    public static Rubro getRubro(String rubCod) throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        Rubro rubro = null;

        try {
            rubro = rubroLogic.getRubro(rubCod);
        } catch (Exception e) {
            throw e;
        }

        return rubro;
    }

    public static List<Rubro> findByCriteriaInRubro(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Rubro> findPageRubro(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findPageRubro(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberRubro() throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findTotalNumberRubro();
    }

    public static List<TipoCategoria> getTipoCategoria()
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.getTipoCategoria();
    }

    public static void saveTipoCategoria(String tcaCod, String tcaNombre)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.saveTipoCategoria(tcaCod, tcaNombre);
    }

    public static void deleteTipoCategoria(String tcaCod)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.deleteTipoCategoria(tcaCod);
    }

    public static void updateTipoCategoria(String tcaCod, String tcaNombre)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.updateTipoCategoria(tcaCod, tcaNombre);
    }

    public static TipoCategoria getTipoCategoria(String tcaCod)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        TipoCategoria tipoCategoria = null;

        try {
            tipoCategoria = tipoCategoriaLogic.getTipoCategoria(tcaCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoCategoria;
    }

    public static List<TipoCategoria> findByCriteriaInTipoCategoria(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoCategoria> findPageTipoCategoria(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findPageTipoCategoria(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoCategoria() throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findTotalNumberTipoCategoria();
    }

    public static List<TipoConcepto> getTipoConcepto()
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.getTipoConcepto();
    }

    public static void saveTipoConcepto(String tcoCod, String tcoNombre)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.saveTipoConcepto(tcoCod, tcoNombre);
    }

    public static void deleteTipoConcepto(String tcoCod)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.deleteTipoConcepto(tcoCod);
    }

    public static void updateTipoConcepto(String tcoCod, String tcoNombre)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.updateTipoConcepto(tcoCod, tcoNombre);
    }

    public static TipoConcepto getTipoConcepto(String tcoCod)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        TipoConcepto tipoConcepto = null;

        try {
            tipoConcepto = tipoConceptoLogic.getTipoConcepto(tcoCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoConcepto;
    }

    public static List<TipoConcepto> findByCriteriaInTipoConcepto(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoConcepto> findPageTipoConcepto(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findPageTipoConcepto(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoConcepto() throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findTotalNumberTipoConcepto();
    }

    public static List<TipoCorrespondencia> getTipoCorrespondencia()
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.getTipoCorrespondencia();
    }

    public static void saveTipoCorrespondencia(String tpcCod, String tpcNombre)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.saveTipoCorrespondencia(tpcCod, tpcNombre);
    }

    public static void deleteTipoCorrespondencia(String tpcCod)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.deleteTipoCorrespondencia(tpcCod);
    }

    public static void updateTipoCorrespondencia(String tpcCod, String tpcNombre)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.updateTipoCorrespondencia(tpcCod, tpcNombre);
    }

    public static TipoCorrespondencia getTipoCorrespondencia(String tpcCod)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        TipoCorrespondencia tipoCorrespondencia = null;

        try {
            tipoCorrespondencia = tipoCorrespondenciaLogic.getTipoCorrespondencia(tpcCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoCorrespondencia;
    }

    public static List<TipoCorrespondencia> findByCriteriaInTipoCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<TipoCorrespondencia> findPageTipoCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findPageTipoCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoCorrespondencia()
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findTotalNumberTipoCorrespondencia();
    }

    public static List<TipoCuentaBancaria> getTipoCuentaBancaria()
        throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();

        return tipoCuentaBancariaLogic.getTipoCuentaBancaria();
    }

    public static void saveTipoCuentaBancaria(String tctaCod, String tctaNombre)
        throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();
        tipoCuentaBancariaLogic.saveTipoCuentaBancaria(tctaCod, tctaNombre);
    }

    public static void deleteTipoCuentaBancaria(String tctaCod)
        throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();
        tipoCuentaBancariaLogic.deleteTipoCuentaBancaria(tctaCod);
    }

    public static void updateTipoCuentaBancaria(String tctaCod,
        String tctaNombre) throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();
        tipoCuentaBancariaLogic.updateTipoCuentaBancaria(tctaCod, tctaNombre);
    }

    public static TipoCuentaBancaria getTipoCuentaBancaria(String tctaCod)
        throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();
        TipoCuentaBancaria tipoCuentaBancaria = null;

        try {
            tipoCuentaBancaria = tipoCuentaBancariaLogic.getTipoCuentaBancaria(tctaCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoCuentaBancaria;
    }

    public static List<TipoCuentaBancaria> findByCriteriaInTipoCuentaBancaria(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();

        return tipoCuentaBancariaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<TipoCuentaBancaria> findPageTipoCuentaBancaria(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();

        return tipoCuentaBancariaLogic.findPageTipoCuentaBancaria(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoCuentaBancaria()
        throws Exception {
        ITipoCuentaBancariaLogic tipoCuentaBancariaLogic = new TipoCuentaBancariaLogic();

        return tipoCuentaBancariaLogic.findTotalNumberTipoCuentaBancaria();
    }

    public static List<TipoDocumento> getTipoDocumento()
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.getTipoDocumento();
    }

    public static void saveTipoDocumento(String tdocCod, String tdocNombre)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.saveTipoDocumento(tdocCod, tdocNombre);
    }

    public static void deleteTipoDocumento(String tdocCod)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.deleteTipoDocumento(tdocCod);
    }

    public static void updateTipoDocumento(String tdocCod, String tdocNombre)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.updateTipoDocumento(tdocCod, tdocNombre);
    }

    public static TipoDocumento getTipoDocumento(String tdocCod)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        TipoDocumento tipoDocumento = null;

        try {
            tipoDocumento = tipoDocumentoLogic.getTipoDocumento(tdocCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoDocumento;
    }

    public static List<TipoDocumento> findByCriteriaInTipoDocumento(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoDocumento> findPageTipoDocumento(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findPageTipoDocumento(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoDocumento() throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findTotalNumberTipoDocumento();
    }

    public static List<TipoUsuario> getTipoUsuario() throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.getTipoUsuario();
    }

    public static void saveTipoUsuario(String tuCod, String tuNombre)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.saveTipoUsuario(tuCod, tuNombre);
    }

    public static void deleteTipoUsuario(String tuCod)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.deleteTipoUsuario(tuCod);
    }

    public static void updateTipoUsuario(String tuCod, String tuNombre)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.updateTipoUsuario(tuCod, tuNombre);
    }

    public static TipoUsuario getTipoUsuario(String tuCod)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        TipoUsuario tipoUsuario = null;

        try {
            tipoUsuario = tipoUsuarioLogic.getTipoUsuario(tuCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoUsuario;
    }

    public static List<TipoUsuario> findByCriteriaInTipoUsuario(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoUsuario> findPageTipoUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findPageTipoUsuario(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoUsuario() throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findTotalNumberTipoUsuario();
    }

    public static List<TipoVehiculo> getTipoVehiculo()
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.getTipoVehiculo();
    }

    public static void saveTipoVehiculo(String tpvCod, String tpvNombre)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.saveTipoVehiculo(tpvCod, tpvNombre);
    }

    public static void deleteTipoVehiculo(String tpvCod)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.deleteTipoVehiculo(tpvCod);
    }

    public static void updateTipoVehiculo(String tpvCod, String tpvNombre)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.updateTipoVehiculo(tpvCod, tpvNombre);
    }

    public static TipoVehiculo getTipoVehiculo(String tpvCod)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        TipoVehiculo tipoVehiculo = null;

        try {
            tipoVehiculo = tipoVehiculoLogic.getTipoVehiculo(tpvCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoVehiculo;
    }

    public static List<TipoVehiculo> findByCriteriaInTipoVehiculo(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoVehiculo> findPageTipoVehiculo(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findPageTipoVehiculo(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoVehiculo() throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findTotalNumberTipoVehiculo();
    }

    public static List<TipoZonaComun> getTipoZonaComun()
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.getTipoZonaComun();
    }

    public static void saveTipoZonaComun(String tzcCod, String tzcNombre)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.saveTipoZonaComun(tzcCod, tzcNombre);
    }

    public static void deleteTipoZonaComun(String tzcCod)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.deleteTipoZonaComun(tzcCod);
    }

    public static void updateTipoZonaComun(String tzcCod, String tzcNombre)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.updateTipoZonaComun(tzcCod, tzcNombre);
    }

    public static TipoZonaComun getTipoZonaComun(String tzcCod)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        TipoZonaComun tipoZonaComun = null;

        try {
            tipoZonaComun = tipoZonaComunLogic.getTipoZonaComun(tzcCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoZonaComun;
    }

    public static List<TipoZonaComun> findByCriteriaInTipoZonaComun(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoZonaComun> findPageTipoZonaComun(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findPageTipoZonaComun(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoZonaComun() throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findTotalNumberTipoZonaComun();
    }

    public static List<TipoZonaExtra> getTipoZonaExtra()
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.getTipoZonaExtra();
    }

    public static void saveTipoZonaExtra(String tzeCod, String tzeNombre)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.saveTipoZonaExtra(tzeCod, tzeNombre);
    }

    public static void deleteTipoZonaExtra(String tzeCod)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.deleteTipoZonaExtra(tzeCod);
    }

    public static void updateTipoZonaExtra(String tzeCod, String tzeNombre)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.updateTipoZonaExtra(tzeCod, tzeNombre);
    }

    public static TipoZonaExtra getTipoZonaExtra(String tzeCod)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        TipoZonaExtra tipoZonaExtra = null;

        try {
            tipoZonaExtra = tipoZonaExtraLogic.getTipoZonaExtra(tzeCod);
        } catch (Exception e) {
            throw e;
        }

        return tipoZonaExtra;
    }

    public static List<TipoZonaExtra> findByCriteriaInTipoZonaExtra(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoZonaExtra> findPageTipoZonaExtra(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findPageTipoZonaExtra(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoZonaExtra() throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findTotalNumberTipoZonaExtra();
    }

    public static List<UnidadResidencial> getUnidadResidencial()
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.getUnidadResidencial();
    }

    public static void saveUnidadResidencial(String unrBarrio,
        String unrDireccion, String unrNit, String unrRazonSocial,
        String unrTelefono, String admCod_Administrador, String ciuCod_Ciudad,
        String estCod_Estado) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.saveUnidadResidencial(unrBarrio, unrDireccion,
            unrNit, unrRazonSocial, unrTelefono, admCod_Administrador,
            ciuCod_Ciudad, estCod_Estado);
    }

    public static void deleteUnidadResidencial(String unrNit)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.deleteUnidadResidencial(unrNit);
    }

    public static void updateUnidadResidencial(String unrBarrio,
        String unrDireccion, String unrNit, String unrRazonSocial,
        String unrTelefono, String admCod_Administrador, String ciuCod_Ciudad,
        String estCod_Estado) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.updateUnidadResidencial(unrBarrio, unrDireccion,
            unrNit, unrRazonSocial, unrTelefono, admCod_Administrador,
            ciuCod_Ciudad, estCod_Estado);
    }

    public static UnidadResidencial getUnidadResidencial(String unrNit)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        UnidadResidencial unidadResidencial = null;

        try {
            unidadResidencial = unidadResidencialLogic.getUnidadResidencial(unrNit);
        } catch (Exception e) {
            throw e;
        }

        return unidadResidencial;
    }

    public static List<UnidadResidencial> findByCriteriaInUnidadResidencial(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<UnidadResidencial> findPageUnidadResidencial(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findPageUnidadResidencial(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberUnidadResidencial()
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findTotalNumberUnidadResidencial();
    }

    public static List<Usuario> getUsuario() throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.getUsuario();
    }

    public static void saveUsuario( String usuPass,
        String estCod_Estado, String perCedula_Persona, String tuCod_TipoUsuario)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.saveUsuario( usuPass, estCod_Estado,
            perCedula_Persona, tuCod_TipoUsuario);
    }

    public static void deleteUsuario(String usuCod) throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.deleteUsuario(usuCod);
    }

    public static void updateUsuario( String usuPass,
        String estCod_Estado, String perCedula_Persona, String tuCod_TipoUsuario)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.updateUsuario( usuPass, estCod_Estado,
            perCedula_Persona, tuCod_TipoUsuario);
    }

    public static Usuario getUsuario(String usuCod) throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        Usuario usuario = null;

        try {
            usuario = usuarioLogic.getUsuario(usuCod);
        } catch (Exception e) {
            throw e;
        }

        return usuario;
    }

    public static List<Usuario> findByCriteriaInUsuario(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Usuario> findPageUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findPageUsuario(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberUsuario() throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findTotalNumberUsuario();
    }

    public static List<Vehiculo> getVehiculo() throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.getVehiculo();
    }

    public static void saveVehiculo(String vehCod, String vehColor,
        Date vehModelo, String estCod_Estado, String marCod_Marca,
        String perCedula_Persona, String tpvCod_TipoVehiculo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.saveVehiculo(vehCod, vehColor, vehModelo, estCod_Estado,
            marCod_Marca, perCedula_Persona, tpvCod_TipoVehiculo);
    }

    public static void deleteVehiculo(String vehCod) throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.deleteVehiculo(vehCod);
    }

    public static void updateVehiculo(String vehCod, String vehColor,
        Date vehModelo, String estCod_Estado, String marCod_Marca,
        String perCedula_Persona, String tpvCod_TipoVehiculo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.updateVehiculo(vehCod, vehColor, vehModelo,
            estCod_Estado, marCod_Marca, perCedula_Persona, tpvCod_TipoVehiculo);
    }

    public static Vehiculo getVehiculo(String vehCod) throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        Vehiculo vehiculo = null;

        try {
            vehiculo = vehiculoLogic.getVehiculo(vehCod);
        } catch (Exception e) {
            throw e;
        }

        return vehiculo;
    }

    public static List<Vehiculo> findByCriteriaInVehiculo(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Vehiculo> findPageVehiculo(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findPageVehiculo(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberVehiculo() throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findTotalNumberVehiculo();
    }

    public static List<ZonaComun> getZonaComun() throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.getZonaComun();
    }

    public static void saveZonaComun( String zcNombre,
        String estCod_Estado, String tzcCod_TipoZonaComun,
        String unrNit_UnidadResidencial) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.saveZonaComun( zcNombre, estCod_Estado,
            tzcCod_TipoZonaComun, unrNit_UnidadResidencial);
    }

    public static void deleteZonaComun(String zcCod) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.deleteZonaComun(zcCod);
    }

    public static void updateZonaComun( String zcNombre,
        String estCod_Estado, String tzcCod_TipoZonaComun,
        String unrNit_UnidadResidencial) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.updateZonaComun(zcNombre, estCod_Estado,
            tzcCod_TipoZonaComun, unrNit_UnidadResidencial);
    }

    public static ZonaComun getZonaComun(String zcCod)
        throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        ZonaComun zonaComun = null;

        try {
            zonaComun = zonaComunLogic.getZonaComun(zcCod);
        } catch (Exception e) {
            throw e;
        }

        return zonaComun;
    }

    public static List<ZonaComun> findByCriteriaInZonaComun(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ZonaComun> findPageZonaComun(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findPageZonaComun(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberZonaComun() throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findTotalNumberZonaComun();
    }

    public static List<ZonaExtra> getZonaExtra() throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.getZonaExtra();
    }

    public static void saveZonaExtra(String zeCod, String zeDimension,
        String estCod_Estado, String inmId_Inmueble, String tzeCod_TipoZonaExtra)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.saveZonaExtra(zeCod, zeDimension, estCod_Estado,
            inmId_Inmueble, tzeCod_TipoZonaExtra);
    }

    public static void deleteZonaExtra(String zeCod) throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.deleteZonaExtra(zeCod);
    }

    public static void updateZonaExtra(String zeCod, String zeDimension,
        String estCod_Estado, String inmId_Inmueble, String tzeCod_TipoZonaExtra)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.updateZonaExtra(zeCod, zeDimension, estCod_Estado,
            inmId_Inmueble, tzeCod_TipoZonaExtra);
    }

    public static ZonaExtra getZonaExtra(String zeCod)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        ZonaExtra zonaExtra = null;

        try {
            zonaExtra = zonaExtraLogic.getZonaExtra(zeCod);
        } catch (Exception e) {
            throw e;
        }

        return zonaExtra;
    }

    public static List<ZonaExtra> findByCriteriaInZonaExtra(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ZonaExtra> findPageZonaExtra(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findPageZonaExtra(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberZonaExtra() throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findTotalNumberZonaExtra();
    }

    public static List<Ciudad > listCiudad = new ArrayList<Ciudad>();
	 public static List<UnidadResidencial > listUnidad= new ArrayList<UnidadResidencial>();
	 public static List<Ciudad> consultarCiudad(String nombre) throws Exception
		{
	    	listCiudad = new ArrayList<Ciudad>();
			ICiudadLogic ciuLogin= new CiudadLogic();
			listCiudad= ciuLogin.consultarCiudad(nombre);
			return listCiudad;
		}
	    

	    public static Usuario obtenerUsuarioContrasenaLogin(String pass,
				String login) throws Exception {
			ILoginLogic loginLogic = new LoginLogic();
			Usuario usuario = null;

			usuario = loginLogic.obtenerUsuarioContrasenaLogin(pass, login);

			return usuario;

		}
	    
	    public static List<Pais> listPais = new ArrayList<Pais>();
	    
	    public static List<Pais> consultarPais(String nombre) throws Exception{
			listPais = new ArrayList<Pais>();
			IPaisLogic pai = new PaisLogic();
			listPais = pai.consultarPais(nombre);
	    	
	    	return listPais;
	    	    	
	    }
	    
	    public static Pais pais = new Pais();
	    public static Pais consultarPaisNombre(String nombre) throws Exception{
	    	pais = new Pais();
	    	IPaisLogic pai = new PaisLogic();
	    	pais = pai.consultar(nombre);
	    	
	    	return pais;
	    		
	    }
	    
	    public static List<Ciudad> consultarCiudadPorNombre (String nombre) throws Exception{
	    	listCiudad = new ArrayList<Ciudad>();
	    	ICiudadLogic ciu = new CiudadLogic();
	    	listCiudad = ciu.consultar(nombre);
	    	return listCiudad;
	    }
	    
	    public static List<Marca> listMarca = new ArrayList<Marca>();
	    
	    public static List<Marca> consultarMarca (String nombre) throws Exception{
	    	listMarca = new ArrayList<Marca>();
	    	IMarcaLogic mar = new MarcaLogic();
	    	listMarca = mar.consultarMarca(nombre);
	    	return listMarca;
	    }
}

